/*
** $Id: ltests.c $
** Internal Module for Debugging of the Lua Implementation
** See Copyright Notice in lua.h
*/

#define ltests_c
#define LUA_CORE

#include "lprefix.h"


#include <limits.h>
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "lua.h"

#include "lapi.h"
#include "lauxlib.h"
#include "lcode.h"
#include "lctype.h"
#include "ldebug.h"
#include "ldo.h"
#include "lfunc.h"
#include "lmem.h"
#include "lopcodes.h"
#include "lopnames.h"
#include "lstate.h"
#include "lstring.h"
#include "ltable.h"
#include "lualib.h"



/*
** The whole module only makes sense with LUA_DEBUG on
*/
#if defined(LUA_DEBUG)


void *l_Trick = 0;


#define obj_at(L,k) s2v(L->ci->func + (k))


static int runC (lua_State *L, lua_State *L1, const char *pc);


static void setnameval (lua_State *L, const char *name, int val) {
    lua_pushinteger(L, val);
    lua_setfield(L, -2, name);
}


static void pushobject (lua_State *L, const TValue *o) {
    setobj2s(L, L->top, o);
    api_incr_top(L);
}


static void badexit (const char *fmt, const char *s1, const char *s2) {
    fprintf(stderr, fmt, s1);
    if (s2)
        fprintf(stderr, "extra info: %s\n", s2);
    /* avoid assertion failures when exiting */
    l_memcontrol.numblocks = l_memcontrol.total = 0;
    exit(EXIT_FAILURE);
}


static int tpanic (lua_State *L) {
    const char *msg = lua_tostring(L, -1);
    if (msg == NULL) msg = "error object is not a string";
    return (badexit("PANIC: unprotected error in call to Lua API (%s)\n",
                    msg, NULL),
            0);  /* do not return to Lua */
}


/*
** Warning function for tests. First, it concatenates all parts of
** a warning in buffer 'buff'. Then, it has three modes:
** - 0.normal: messages starting with '#' are shown on standard output;
** - other messages abort the tests (they represent real warning
** conditions; the standard tests should not generate these conditions
** unexpectedly);
** - 1.allow: all messages are shown;
** - 2.store: all warnings go to the global '_WARN';
*/
static void warnf (void *ud, const char *msg, int tocont) {
    lua_State *L = cast(lua_State *, ud);
    static char buff[200] = "";  /* should be enough for tests... */
    static int onoff = 0;
    static int mode = 0;  /* start in normal mode */
    static int lasttocont = 0;
    if (!lasttocont && !tocont && *msg == '@') {  /* control message? */
        if (buff[0] != '\0')
            badexit("Control warning during warning: %s\naborting...\n", msg, buff);
        if (strcmp(msg, "@off") == 0)
            onoff = 0;
        else if (strcmp(msg, "@on") == 0)
            onoff = 1;
        else if (strcmp(msg, "@normal") == 0)
            mode = 0;
        else if (strcmp(msg, "@allow") == 0)
            mode = 1;
        else if (strcmp(msg, "@store") == 0)
            mode = 2;
        else
            badexit("Invalid control warning in test mode: %s\naborting...\n",
                    msg, NULL);
        return;
    }
    lasttocont = tocont;
    if (strlen(msg) >= sizeof(buff) - strlen(buff))
        badexit("warnf-buffer overflow (%s)\n", msg, buff);
    strcat(buff, msg);  /* add new message to current warning */
    if (!tocont) {  /* message finished? */
        lua_unlock(L);
        lua_getglobal(L, "_WARN");
        if (!lua_toboolean(L, -1))
            lua_pop(L, 1);  /* ok, no previous unexpected warning */
        else {
            badexit("Unhandled warning in store mode: %s\naborting...\n",
                    lua_tostring(L, -1), buff);
        }
        lua_lock(L);
        switch (mode) {
        case 0: {  /* normal */
            if (buff[0] != '#' && onoff)  /* unexpected warning? */
                badexit("Unexpected warning in test mode: %s\naborting...\n",
                        buff, NULL);
            }  /* FALLTHROUGH */
        case 1: {  /* allow */
            if (onoff)
                fprintf(stderr, "Lua warning: %s\n", buff);  /* print warning */
            break;
        }
        case 2: {  /* store */
            lua_unlock(L);
            lua_pushstring(L, buff);
            lua_setglobal(L, "_WARN");  /* assign message to global '_WARN' */
            lua_lock(L);
            break;
        }
        }
        buff[0] = '\0';  /* prepare buffer for next warning */
    }
}


/*
** {======================================================================
** Controlled version for realloc.
** =======================================================================
*/

#define MARK  0x55  /* 01010101 (a nice pattern) */

typedef union Header {
    LUAI_MAXALIGN;
    struct {
        size_t size;
        int type;
    } d;
} Header;


#if !defined(EXTERNMEMCHECK)

/* full memory check */
#define MARKSIZE 16  /* size of marks after each block */
#define fillmem(mem,size) memset(mem, -MARK, size)

#else

/* external memory check: don't do it twice */
#define MARKSIZE 0
#define fillmem(mem,size) /* empty */

#endif


Memcontrol l_memcontrol =
{   0, 0UL, 0UL, 0UL, 0UL, (~0UL),
    {0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}
};


static void freeblock (Memcontrol *mc, Header *block) {
    if (block) {
        size_t size = block->d.size;
        int i;
        for (i = 0; i < MARKSIZE; i++)  /* check marks after block */
            lua_assert(*(cast_charp(block + 1) + size + i) == MARK);
        mc->objcount[block->d.type]--;
        fillmem(block, sizeof(Header) + size + MARKSIZE);  /* erase block */
        free(block);  /* actually free block */
        mc->numblocks--;  /* update counts */
        mc->total -= size;
    }
}


void *debug_realloc (void *ud, void *b, size_t oldsize, size_t size) {
    Memcontrol *mc = cast(Memcontrol *, ud);
    Header *block = cast(Header *, b);
    int type;
    if (mc->memlimit == 0) {  /* first time? */
        char *limit = getenv("MEMLIMIT");  /* initialize memory limit */
        mc->memlimit = limit ? strtoul(limit, NULL, 10) : ULONG_MAX;
    }
    if (block == NULL) {
        type = (oldsize < LUA_NUMTAGS) ? oldsize : 0;
        oldsize = 0;
    }
    else {
        block--;  /* go to real header */
        type = block->d.type;
        lua_assert(oldsize == block->d.size);
    }
    if (size == 0) {
        freeblock(mc, block);
        return NULL;
    }
    if (mc->failnext) {
        mc->failnext = 0;
        return NULL;  /* fake a single memory allocation error */
    }
    if (mc->countlimit != ~0UL && size != oldsize) {  /* count limit in use? */
        if (mc->countlimit == 0)
            return NULL;  /* fake a memory allocation error */
        mc->countlimit--;
    }
    if (size > oldsize && mc->total+size-oldsize > mc->memlimit)
        return NULL;  /* fake a memory allocation error */
    else {
        Header *newblock;
        int i;
        size_t commonsize = (oldsize < size) ? oldsize : size;
        size_t realsize = sizeof(Header) + size + MARKSIZE;
        if (realsize < size) return NULL;  /* arithmetic overflow! */
        newblock = cast(Header *, malloc(realsize));  /* alloc a new block */
        if (newblock == NULL)
            return NULL;  /* really out of memory? */
        if (block) {
            memcpy(newblock + 1, block + 1, commonsize);  /* copy old contents */
            freeblock(mc, block);  /* erase (and check) old copy */
        }
        /* initialize new part of the block with something weird */
        fillmem(cast_charp(newblock + 1) + commonsize, size - commonsize);
        /* initialize marks after block */
        for (i = 0; i < MARKSIZE; i++)
            *(cast_charp(newblock + 1) + size + i) = MARK;
        newblock->d.size = size;
        newblock->d.type = type;
        mc->total += size;
        if (mc->total > mc->maxmem)
            mc->maxmem = mc->total;
        mc->numblocks++;
        mc->objcount[type]++;
        return newblock + 1;
    }
}


/* }====================================================================== */



/*
** {======================================================
** Functions to check memory consistency
** =======================================================
*/


/*
** Check GC invariants. For incremental mode, a black object cannot
** point to a white one. For generational mode, really old objects
** cannot point to young objects. Both old1 and touched2 objects
** cannot point to new objects (but can point to survivals).
** (Threads and open upvalues, despite being marked "really old",
** continue to be visited in all collections, and therefore can point to
** new objects. They, and only they, are old but gray.)
*/
static int testobjref1 (global_State *g, GCObject *f, GCObject *t) {
    if (isdead(g,t)) return 0;
    if (issweepphase(g))
        return 1;  /* no invariants */
    else if (g->gckind == KGC_INC)
        return !(isblack(f) && iswhite(t));  /* basic incremental invariant */
    else {  /* generational mode */
        if ((getage(f) == G_OLD && isblack(f)) && !isold(t))
            return 0;
        if (((getage(f) == G_OLD1 || getage(f) == G_TOUCHED2) && isblack(f)) &&
                getage(t) == G_NEW)
            return 0;
        return 1;
    }
}


static void printobj (global_State *g, GCObject *o) {
    printf("||%s(%p)-%c%c(%02X)||",
           ttypename(novariant(o->tt)), (void *)o,
           isdead(g,o) ? 'd' : isblack(o) ? 'b' : iswhite(o) ? 'w' : 'g',
           "ns01oTt"[getage(o)], o->marked);
    if (o->tt == LUA_VSHRSTR || o->tt == LUA_VLNGSTR)
        printf(" '%s'", getstr(gco2ts(o)));
}


void lua_printobj (lua_State *L, struct GCObject *o) {
    printobj(G(L), o);
}

static int testobjref (global_State *g, GCObject *f, GCObject *t) {
    int r1 = testobjref1(g, f, t);
    if (!r1) {
        printf("%d(%02X) - ", g->gcstate, g->currentwhite);
        printobj(g, f);
        printf("  ->  ");
        printobj(g, t);
        printf("\n");
    }
    return r1;
}

#define checkobjref(g,f,t)  \
 { if (t) lua_longassert(testobjref(g,f,obj2gco(t))); }


static void checkvalref (global_State *g, GCObject *f, const TValue *t) {
    lua_assert(!iscollectable(t) ||
               (righttt(t) && testobjref(g, f, gcvalue(t))));
}


static void checktable (global_State *g, Table *h) {
    unsigned int i;
    unsigned int asize = luaH_realasize(h);
    Node *n, *limit = gnode(h, sizenode(h));
    GCObject *hgc = obj2gco(h);
    checkobjref(g, hgc, h->metatable);
    for (i = 0; i < asize; i++)
        checkvalref(g, hgc, &h->array[i]);
    for (n = gnode(h, 0); n < limit; n++) {
        if (!isempty(gval(n))) {
            TValue k;
            getnodekey(g->mainthread, &k, n);
            lua_assert(!keyisnil(n));
            checkvalref(g, hgc, &k);
            checkvalref(g, hgc, gval(n));
        }
    }
}


static void checkudata (global_State *g, Udata *u) {
    int i;
    GCObject *hgc = obj2gco(u);
    checkobjref(g, hgc, u->metatable);
    for (i = 0; i < u->nuvalue; i++)
        checkvalref(g, hgc, &u->uv[i].uv);
}


/*
** All marks are conditional because a GC may happen while the
** prototype is still being created
*/
static void checkproto (global_State *g, Proto *f) {
    int i;
    GCObject *fgc = obj2gco(f);
    checkobjref(g, fgc, f->source);
    for (i=0; i<f->sizek; i++) {
        if (ttisstring(f->k + i))
            checkobjref(g, fgc, tsvalue(f->k + i));
    }
    for (i=0; i<f->sizeupvalues; i++)
        checkobjref(g, fgc, f->upvalues[i].name);
    for (i=0; i<f->sizep; i++)
        checkobjref(g, fgc, f->p[i]);
    for (i=0; i<f->sizelocvars; i++)
        checkobjref(g, fgc, f->locvars[i].varname);
}


static void checkCclosure (global_State *g, CClosure *cl) {
    GCObject *clgc = obj2gco(cl);
    int i;
    for (i = 0; i < cl->nupvalues; i++)
        checkvalref(g, clgc, &cl->upvalue[i]);
}


static void checkLclosure (global_State *g, LClosure *cl) {
    GCObject *clgc = obj2gco(cl);
    int i;
    checkobjref(g, clgc, cl->p);
    for (i=0; i<cl->nupvalues; i++) {
        UpVal *uv = cl->upvals[i];
        if (uv) {
            checkobjref(g, clgc, uv);
            if (!upisopen(uv))
                checkvalref(g, obj2gco(uv), uv->v);
        }
    }
}


static int lua_checkpc (CallInfo *ci) {
    if (!isLua(ci)) return 1;
    else {
        StkId f = ci->func;
        Proto *p = clLvalue(s2v(f))->p;
        return p->code <= ci->u.l.savedpc &&
               ci->u.l.savedpc <= p->code + p->sizecode;
    }
}


static void checkstack (global_State *g, lua_State *L1) {
    StkId o;
    CallInfo *ci;
    UpVal *uv;
    lua_assert(!isdead(g, L1));
    if (L1->stack == NULL) {  /* incomplete thread? */
        lua_assert(L1->openupval == NULL && L1->ci == NULL);
        return;
    }
    for (uv = L1->openupval; uv != NULL; uv = uv->u.open.next)
        lua_assert(upisopen(uv));  /* must be open */
    lua_assert(L1->top <= L1->stack_last);
    for (ci = L1->ci; ci != NULL; ci = ci->previous) {
        lua_assert(ci->top <= L1->stack_last);
        lua_assert(lua_checkpc(ci));
    }
    for (o = L1->stack; o < L1->stack_last; o++)
        checkliveness(L1, s2v(o));  /* entire stack must have valid values */
}


static void checkrefs (global_State *g, GCObject *o) {
    switch (o->tt) {
    case LUA_VUSERDATA: {
        checkudata(g, gco2u(o));
        break;
    }
    case LUA_VUPVAL: {
        checkvalref(g, o, gco2upv(o)->v);
        break;
    }
    case LUA_VTABLE: {
        checktable(g, gco2t(o));
        break;
    }
    case LUA_VTHREAD: {
        checkstack(g, gco2th(o));
        break;
    }
    case LUA_VLCL: {
        checkLclosure(g, gco2lcl(o));
        break;
    }
    case LUA_VCCL: {
        checkCclosure(g, gco2ccl(o));
        break;
    }
    case LUA_VPROTO: {
        checkproto(g, gco2p(o));
        break;
    }
    case LUA_VSHRSTR:
    case LUA_VLNGSTR: {
        lua_assert(!isgray(o));  /* strings are never gray */
        break;
    }
    default:
        lua_assert(0);
    }
}


/*
** Check consistency of an object:
** - Dead objects can only happen in the 'allgc' list during a sweep
** phase (controlled by the caller through 'maybedead').
** - During pause, all objects must be white.
** - In generational mode:
**   * objects must be old enough for their lists ('listage').
**   * old objects cannot be white.
**   * old objects must be black, except for 'touched1', 'old0',
** threads, and open upvalues.
*/
static void checkobject (global_State *g, GCObject *o, int maybedead,
                         int listage) {
    if (isdead(g, o))
        lua_assert(maybedead);
    else {
        lua_assert(g->gcstate != GCSpause || iswhite(o));
        if (g->gckind == KGC_GEN) {  /* generational mode? */
            lua_assert(getage(o) >= listage);
            lua_assert(!iswhite(o) || !isold(o));
            if (isold(o)) {
                lua_assert(isblack(o) ||
                           getage(o) == G_TOUCHED1 ||
                           getage(o) == G_OLD0 ||
                           o->tt == LUA_VTHREAD ||
                           (o->tt == LUA_VUPVAL && upisopen(gco2upv(o))));
            }
        }
        checkrefs(g, o);
    }
}


static lu_mem checkgraylist (global_State *g, GCObject *o) {
    int total = 0;  /* count number of elements in the list */
    ((void)g);  /* better to keep it available if we need to print an object */
    while (o) {
        lua_assert(!!isgray(o) ^ (getage(o) == G_TOUCHED2));
        lua_assert(!testbit(o->marked, TESTBIT));
        if (keepinvariant(g))
            l_setbit(o->marked, TESTBIT);  /* mark that object is in a gray list */
        total++;
        switch (o->tt) {
        case LUA_VTABLE:
            o = gco2t(o)->gclist;
            break;
        case LUA_VLCL:
            o = gco2lcl(o)->gclist;
            break;
        case LUA_VCCL:
            o = gco2ccl(o)->gclist;
            break;
        case LUA_VTHREAD:
            o = gco2th(o)->gclist;
            break;
        case LUA_VPROTO:
            o = gco2p(o)->gclist;
            break;
        case LUA_VUSERDATA:
            lua_assert(gco2u(o)->nuvalue > 0);
            o = gco2u(o)->gclist;
            break;
        default:
            lua_assert(0);  /* other objects cannot be in a gray list */
        }
    }
    return total;
}


/*
** Check objects in gray lists.
*/
static lu_mem checkgrays (global_State *g) {
    int total = 0;  /* count number of elements in all lists */
    if (!keepinvariant(g)) return total;
    total += checkgraylist(g, g->gray);
    total += checkgraylist(g, g->grayagain);
    total += checkgraylist(g, g->weak);
    total += checkgraylist(g, g->allweak);
    total += checkgraylist(g, g->ephemeron);
    return total;
}


/*
** Check whether 'o' should be in a gray list. If so, increment
** 'count' and check its TESTBIT. (It must have been previously set by
** 'checkgraylist'.)
*/
static void incifingray (global_State *g, GCObject *o, lu_mem *count) {
    if (!keepinvariant(g))
        return;  /* gray lists not being kept in these phases */
    if (o->tt == LUA_VUPVAL) {
        /* only open upvalues can be gray */
        lua_assert(!isgray(o) || upisopen(gco2upv(o)));
        return;  /* upvalues are never in gray lists */
    }
    /* these are the ones that must be in gray lists */
    if (isgray(o) || getage(o) == G_TOUCHED2) {
        (*count)++;
        lua_assert(testbit(o->marked, TESTBIT));
        resetbit(o->marked, TESTBIT);  /* prepare for next cycle */
    }
}


static lu_mem checklist (global_State *g, int maybedead, int tof,
                         GCObject *newl, GCObject *survival, GCObject *old, GCObject *reallyold) {
    GCObject *o;
    lu_mem total = 0;  /* number of object that should be in  gray lists */
    for (o = newl; o != survival; o = o->next) {
        checkobject(g, o, maybedead, G_NEW);
        incifingray(g, o, &total);
        lua_assert(!tof == !tofinalize(o));
    }
    for (o = survival; o != old; o = o->next) {
        checkobject(g, o, 0, G_SURVIVAL);
        incifingray(g, o, &total);
        lua_assert(!tof == !tofinalize(o));
    }
    for (o = old; o != reallyold; o = o->next) {
        checkobject(g, o, 0, G_OLD1);
        incifingray(g, o, &total);
        lua_assert(!tof == !tofinalize(o));
    }
    for (o = reallyold; o != NULL; o = o->next) {
        checkobject(g, o, 0, G_OLD);
        incifingray(g, o, &total);
        lua_assert(!tof == !tofinalize(o));
    }
    return total;
}


int lua_checkmemory (lua_State *L) {
    global_State *g = G(L);
    GCObject *o;
    int maybedead;
    lu_mem totalin;  /* total of objects that are in gray lists */
    lu_mem totalshould;  /* total of objects that should be in gray lists */
    if (keepinvariant(g)) {
        lua_assert(!iswhite(g->mainthread));
        lua_assert(!iswhite(gcvalue(&g->l_registry)));
    }
    lua_assert(!isdead(g, gcvalue(&g->l_registry)));
    lua_assert(g->sweepgc == NULL || issweepphase(g));
    totalin = checkgrays(g);

    /* check 'fixedgc' list */
    for (o = g->fixedgc; o != NULL; o = o->next) {
        lua_assert(o->tt == LUA_VSHRSTR && isgray(o) && getage(o) == G_OLD);
    }

    /* check 'allgc' list */
    maybedead = (GCSatomic < g->gcstate && g->gcstate <= GCSswpallgc);
    totalshould = checklist(g, maybedead, 0, g->allgc,
                            g->survival, g->old1, g->reallyold);

    /* check 'finobj' list */
    totalshould += checklist(g, 0, 1, g->finobj,
                             g->finobjsur, g->finobjold1, g->finobjrold);

    /* check 'tobefnz' list */
    for (o = g->tobefnz; o != NULL; o = o->next) {
        checkobject(g, o, 0, G_NEW);
        incifingray(g, o, &totalshould);
        lua_assert(tofinalize(o));
        lua_assert(o->tt == LUA_VUSERDATA || o->tt == LUA_VTABLE);
    }
    if (keepinvariant(g))
        lua_assert(totalin == totalshould);
    return 0;
}

/* }====================================================== */



/*
** {======================================================
** Disassembler
** =======================================================
*/


static char *buildop (Proto *p, int pc, char *buff) {
    char *obuff = buff;
    Instruction i = p->code[pc];
    OpCode o = GET_OPCODE(i);
    const char *name = opnames[o];
    int line = luaG_getfuncline(p, pc);
    int lineinfo = (p->lineinfo != NULL) ? p->lineinfo[pc] : 0;
    if (lineinfo == ABSLINEINFO)
        buff += sprintf(buff, "(__");
    else
        buff += sprintf(buff, "(%2d", lineinfo);
    buff += sprintf(buff, " - %4d) %4d - ", line, pc);
    switch (getOpMode(o)) {
    case iABC:
        sprintf(buff, "%-12s%4d %4d %4d%s", name,
                GETARG_A(i), GETARG_B(i), GETARG_C(i),
                GETARG_k(i) ? " (k)" : "");
        break;
    case iABx:
        sprintf(buff, "%-12s%4d %4d", name, GETARG_A(i), GETARG_Bx(i));
        break;
    case iAsBx:
        sprintf(buff, "%-12s%4d %4d", name, GETARG_A(i), GETARG_sBx(i));
        break;
    case iAx:
        sprintf(buff, "%-12s%4d", name, GETARG_Ax(i));
        break;
    case isJ:
        sprintf(buff, "%-12s%4d", name, GETARG_sJ(i));
        break;
    }
    return obuff;
}


#if 0
void luaI_printcode (Proto *pt, int size) {
    int pc;
    for (pc=0; pc<size; pc++) {
        char buff[100];
        printf("%s\n", buildop(pt, pc, buff));
    }
    printf("-------\n");
}


void luaI_printinst (Proto *pt, int pc) {
    char buff[100];
    printf("%s\n", buildop(pt, pc, buff));
}
#endif


static int listcode (lua_State *L) {
    int pc;
    Proto *p;
    luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
                  1, "Lua function expected");
    p = getproto(obj_at(L, 1));
    lua_newtable(L);
    setnameval(L, "maxstack", p->maxstacksize);
    setnameval(L, "numparams", p->numparams);
    for (pc=0; pc<p->sizecode; pc++) {
        char buff[100];
        lua_pushinteger(L, pc+1);
        lua_pushstring(L, buildop(p, pc, buff));
        lua_settable(L, -3);
    }
    return 1;
}


static int printcode (lua_State *L) {
    int pc;
    Proto *p;
    luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
                  1, "Lua function expected");
    p = getproto(obj_at(L, 1));
    printf("maxstack: %d\n", p->maxstacksize);
    printf("numparams: %d\n", p->numparams);
    for (pc=0; pc<p->sizecode; pc++) {
        char buff[100];
        printf("%s\n", buildop(p, pc, buff));
    }
    return 0;
}


static int listk (lua_State *L) {
    Proto *p;
    int i;
    luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
                  1, "Lua function expected");
    p = getproto(obj_at(L, 1));
    lua_createtable(L, p->sizek, 0);
    for (i=0; i<p->sizek; i++) {
        pushobject(L, p->k+i);
        lua_rawseti(L, -2, i+1);
    }
    return 1;
}


static int listabslineinfo (lua_State *L) {
    Proto *p;
    int i;
    luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
                  1, "Lua function expected");
    p = getproto(obj_at(L, 1));
    luaL_argcheck(L, p->abslineinfo != NULL, 1, "function has no debug info");
    lua_createtable(L, 2 * p->sizeabslineinfo, 0);
    for (i=0; i < p->sizeabslineinfo; i++) {
        lua_pushinteger(L, p->abslineinfo[i].pc);
        lua_rawseti(L, -2, 2 * i + 1);
        lua_pushinteger(L, p->abslineinfo[i].line);
        lua_rawseti(L, -2, 2 * i + 2);
    }
    return 1;
}


static int listlocals (lua_State *L) {
    Proto *p;
    int pc = cast_int(luaL_checkinteger(L, 2)) - 1;
    int i = 0;
    const char *name;
    luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
                  1, "Lua function expected");
    p = getproto(obj_at(L, 1));
    while ((name = luaF_getlocalname(p, ++i, pc)) != NULL)
        lua_pushstring(L, name);
    return i-1;
}

/* }====================================================== */



static void printstack (lua_State *L) {
    int i;
    int n = lua_gettop(L);
    printf("stack: >>\n");
    for (i = 1; i <= n; i++) {
        printf("%3d: %s\n", i, luaL_tolstring(L, i, NULL));
        lua_pop(L, 1);
    }
    printf("<<\n");
}


static int get_limits (lua_State *L) {
    lua_createtable(L, 0, 6);
    setnameval(L, "IS32INT", LUAI_IS32INT);
    setnameval(L, "MAXARG_Ax", MAXARG_Ax);
    setnameval(L, "MAXARG_Bx", MAXARG_Bx);
    setnameval(L, "OFFSET_sBx", OFFSET_sBx);
    setnameval(L, "LFPF", LFIELDS_PER_FLUSH);
    setnameval(L, "NUM_OPCODES", NUM_OPCODES);
    return 1;
}


static int mem_query (lua_State *L) {
    if (lua_isnone(L, 1)) {
        lua_pushinteger(L, l_memcontrol.total);
        lua_pushinteger(L, l_memcontrol.numblocks);
        lua_pushinteger(L, l_memcontrol.maxmem);
        return 3;
    }
    else if (lua_isnumber(L, 1)) {
        unsigned long limit = cast(unsigned long, luaL_checkinteger(L, 1));
        if (limit == 0) limit = ULONG_MAX;
        l_memcontrol.memlimit = limit;
        return 0;
    }
    else {
        const char *t = luaL_checkstring(L, 1);
        int i;
        for (i = LUA_NUMTAGS - 1; i >= 0; i--) {
            if (strcmp(t, ttypename(i)) == 0) {
                lua_pushinteger(L, l_memcontrol.objcount[i]);
                return 1;
            }
        }
        return luaL_error(L, "unknown type '%s'", t);
    }
}


static int alloc_count (lua_State *L) {
    if (lua_isnone(L, 1))
        l_memcontrol.countlimit = ~0L;
    else
        l_memcontrol.countlimit = luaL_checkinteger(L, 1);
    return 0;
}


static int alloc_failnext (lua_State *L) {
    UNUSED(L);
    l_memcontrol.failnext = 1;
    return 0;
}


static int settrick (lua_State *L) {
    if (ttisnil(obj_at(L, 1)))
        l_Trick = NULL;
    else
        l_Trick = gcvalue(obj_at(L, 1));
    return 0;
}


static int gc_color (lua_State *L) {
    TValue *o;
    luaL_checkany(L, 1);
    o = obj_at(L, 1);
    if (!iscollectable(o))
        lua_pushstring(L, "no collectable");
    else {
        GCObject *obj = gcvalue(o);
        lua_pushstring(L, isdead(G(L), obj) ? "dead" :
                       iswhite(obj) ? "white" :
                       isblack(obj) ? "black" : "gray");
    }
    return 1;
}


static int gc_age (lua_State *L) {
    TValue *o;
    luaL_checkany(L, 1);
    o = obj_at(L, 1);
    if (!iscollectable(o))
        lua_pushstring(L, "no collectable");
    else {
        static const char *gennames[] = {"new", "survival", "old0", "old1",
                                         "old", "touched1", "touched2"
                                        };
        GCObject *obj = gcvalue(o);
        lua_pushstring(L, gennames[getage(obj)]);
    }
    return 1;
}


static int gc_printobj (lua_State *L) {
    TValue *o;
    luaL_checkany(L, 1);
    o = obj_at(L, 1);
    if (!iscollectable(o))
        printf("no collectable\n");
    else {
        GCObject *obj = gcvalue(o);
        printobj(G(L), obj);
        printf("\n");
    }
    return 0;
}


static int gc_state (lua_State *L) {
    static const char *statenames[] = {
        "propagate", "atomic", "enteratomic", "sweepallgc", "sweepfinobj",
        "sweeptobefnz", "sweepend", "callfin", "pause", ""
    };
    static const int states[] = {
        GCSpropagate, GCSenteratomic, GCSatomic, GCSswpallgc, GCSswpfinobj,
        GCSswptobefnz, GCSswpend, GCScallfin, GCSpause, -1
    };
    int option = states[luaL_checkoption(L, 1, "", statenames)];
    if (option == -1) {
        lua_pushstring(L, statenames[G(L)->gcstate]);
        return 1;
    }
    else {
        global_State *g = G(L);
        if (G(L)->gckind == KGC_GEN)
            luaL_error(L, "cannot change states in generational mode");
        lua_lock(L);
        if (option < g->gcstate) {  /* must cross 'pause'? */
            luaC_runtilstate(L, bitmask(GCSpause));  /* run until pause */
        }
        luaC_runtilstate(L, bitmask(option));
        lua_assert(G(L)->gcstate == option);
        lua_unlock(L);
        return 0;
    }
}


static int hash_query (lua_State *L) {
    if (lua_isnone(L, 2)) {
        luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "string expected");
        lua_pushinteger(L, tsvalue(obj_at(L, 1))->hash);
    }
    else {
        TValue *o = obj_at(L, 1);
        Table *t;
        luaL_checktype(L, 2, LUA_TTABLE);
        t = hvalue(obj_at(L, 2));
        lua_pushinteger(L, luaH_mainposition(t, o) - t->node);
    }
    return 1;
}


static int stacklevel (lua_State *L) {
    unsigned long a = 0;
    lua_pushinteger(L, (L->top - L->stack));
    lua_pushinteger(L, stacksize(L));
    lua_pushinteger(L, L->nCcalls);
    lua_pushinteger(L, L->nci);
    lua_pushinteger(L, (unsigned long)&a);
    return 5;
}


static int table_query (lua_State *L) {
    const Table *t;
    int i = cast_int(luaL_optinteger(L, 2, -1));
    unsigned int asize;
    luaL_checktype(L, 1, LUA_TTABLE);
    t = hvalue(obj_at(L, 1));
    asize = luaH_realasize(t);
    if (i == -1) {
        lua_pushinteger(L, asize);
        lua_pushinteger(L, allocsizenode(t));
        lua_pushinteger(L, isdummy(t) ? 0 : t->lastfree - t->node);
        lua_pushinteger(L, t->alimit);
        return 4;
    }
    else if ((unsigned int)i < asize) {
        lua_pushinteger(L, i);
        pushobject(L, &t->array[i]);
        lua_pushnil(L);
    }
    else if ((i -= asize) < sizenode(t)) {
        TValue k;
        getnodekey(L, &k, gnode(t, i));
        if (!isempty(gval(gnode(t, i))) ||
                ttisnil(&k) ||
                ttisnumber(&k)) {
            pushobject(L, &k);
        }
        else
            lua_pushliteral(L, "<undef>");
        pushobject(L, gval(gnode(t, i)));
        if (gnext(&t->node[i]) != 0)
            lua_pushinteger(L, gnext(&t->node[i]));
        else
            lua_pushnil(L);
    }
    return 3;
}


static int string_query (lua_State *L) {
    stringtable *tb = &G(L)->strt;
    int s = cast_int(luaL_optinteger(L, 1, 0)) - 1;
    if (s == -1) {
        lua_pushinteger(L,tb->size);
        lua_pushinteger(L,tb->nuse);
        return 2;
    }
    else if (s < tb->size) {
        TString *ts;
        int n = 0;
        for (ts = tb->hash[s]; ts != NULL; ts = ts->u.hnext) {
            setsvalue2s(L, L->top, ts);
            api_incr_top(L);
            n++;
        }
        return n;
    }
    else return 0;
}


static int tref (lua_State *L) {
    int level = lua_gettop(L);
    luaL_checkany(L, 1);
    lua_pushvalue(L, 1);
    lua_pushinteger(L, luaL_ref(L, LUA_REGISTRYINDEX));
    lua_assert(lua_gettop(L) == level+1);  /* +1 for result */
    return 1;
}

static int getref (lua_State *L) {
    int level = lua_gettop(L);
    lua_rawgeti(L, LUA_REGISTRYINDEX, luaL_checkinteger(L, 1));
    lua_assert(lua_gettop(L) == level+1);
    return 1;
}

static int unref (lua_State *L) {
    int level = lua_gettop(L);
    luaL_unref(L, LUA_REGISTRYINDEX, cast_int(luaL_checkinteger(L, 1)));
    lua_assert(lua_gettop(L) == level);
    return 0;
}


static int upvalue (lua_State *L) {
    int n = cast_int(luaL_checkinteger(L, 2));
    luaL_checktype(L, 1, LUA_TFUNCTION);
    if (lua_isnone(L, 3)) {
        const char *name = lua_getupvalue(L, 1, n);
        if (name == NULL) return 0;
        lua_pushstring(L, name);
        return 2;
    }
    else {
        const char *name = lua_setupvalue(L, 1, n);
        lua_pushstring(L, name);
        return 1;
    }
}


static int newuserdata (lua_State *L) {
    size_t size = cast_sizet(luaL_optinteger(L, 1, 0));
    int nuv = luaL_optinteger(L, 2, 0);
    char *p = cast_charp(lua_newuserdatauv(L, size, nuv));
    while (size--) *p++ = '\0';
    return 1;
}


static int pushuserdata (lua_State *L) {
    lua_Integer u = luaL_checkinteger(L, 1);
    lua_pushlightuserdata(L, cast_voidp(cast_sizet(u)));
    return 1;
}


static int udataval (lua_State *L) {
    lua_pushinteger(L, cast(long, lua_touserdata(L, 1)));
    return 1;
}


static int doonnewstack (lua_State *L) {
    lua_State *L1 = lua_newthread(L);
    size_t l;
    const char *s = luaL_checklstring(L, 1, &l);
    int status = luaL_loadbuffer(L1, s, l, s);
    if (status == LUA_OK)
        status = lua_pcall(L1, 0, 0, 0);
    lua_pushinteger(L, status);
    return 1;
}


static int s2d (lua_State *L) {
    lua_pushnumber(L, cast_num(*cast(const double *, luaL_checkstring(L, 1))));
    return 1;
}


static int d2s (lua_State *L) {
    double d = cast(double, luaL_checknumber(L, 1));
    lua_pushlstring(L, cast_charp(&d), sizeof(d));
    return 1;
}


static int num2int (lua_State *L) {
    lua_pushinteger(L, lua_tointeger(L, 1));
    return 1;
}


static int newstate (lua_State *L) {
    void *ud;
    lua_Alloc f = lua_getallocf(L, &ud);
    lua_State *L1 = lua_newstate(f, ud);
    if (L1) {
        lua_atpanic(L1, tpanic);
        lua_pushlightuserdata(L, L1);
    }
    else
        lua_pushnil(L);
    return 1;
}


static lua_State *getstate (lua_State *L) {
    lua_State *L1 = cast(lua_State *, lua_touserdata(L, 1));
    luaL_argcheck(L, L1 != NULL, 1, "state expected");
    return L1;
}


static int loadlib (lua_State *L) {
    static const luaL_Reg libs[] = {
        {LUA_GNAME, luaopen_base},
        {"coroutine", luaopen_coroutine},
        {"debug", luaopen_debug},
        {"io", luaopen_io},
        {"os", luaopen_os},
        {"math", luaopen_math},
        {"string", luaopen_string},
        {"table", luaopen_table},
        {"T", luaB_opentests},
        {NULL, NULL}
    };
    lua_State *L1 = getstate(L);
    int i;
    luaL_requiref(L1, "package", luaopen_package, 0);
    lua_assert(lua_type(L1, -1) == LUA_TTABLE);
    /* 'requiref' should not reload module already loaded... */
    luaL_requiref(L1, "package", NULL, 1);  /* seg. fault if it reloads */
    /* ...but should return the same module */
    lua_assert(lua_compare(L1, -1, -2, LUA_OPEQ));
    luaL_getsubtable(L1, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
    for (i = 0; libs[i].name; i++) {
        lua_pushcfunction(L1, libs[i].func);
        lua_setfield(L1, -2, libs[i].name);
    }
    return 0;
}

static int closestate (lua_State *L) {
    lua_State *L1 = getstate(L);
    lua_close(L1);
    return 0;
}

static int doremote (lua_State *L) {
    lua_State *L1 = getstate(L);
    size_t lcode;
    const char *code = luaL_checklstring(L, 2, &lcode);
    int status;
    lua_settop(L1, 0);
    status = luaL_loadbuffer(L1, code, lcode, code);
    if (status == LUA_OK)
        status = lua_pcall(L1, 0, LUA_MULTRET, 0);
    if (status != LUA_OK) {
        lua_pushnil(L);
        lua_pushstring(L, lua_tostring(L1, -1));
        lua_pushinteger(L, status);
        return 3;
    }
    else {
        int i = 0;
        while (!lua_isnone(L1, ++i))
            lua_pushstring(L, lua_tostring(L1, i));
        lua_pop(L1, i-1);
        return i-1;
    }
}


static int log2_aux (lua_State *L) {
    unsigned int x = (unsigned int)luaL_checkinteger(L, 1);
    lua_pushinteger(L, luaO_ceillog2(x));
    return 1;
}


struct Aux {
    jmp_buf jb;
    const char *paniccode;
    lua_State *L;
};

/*
** does a long-jump back to "main program".
*/
static int panicback (lua_State *L) {
    struct Aux *b;
    lua_checkstack(L, 1);  /* open space for 'Aux' struct */
    lua_getfield(L, LUA_REGISTRYINDEX, "_jmpbuf");  /* get 'Aux' struct */
    b = (struct Aux *)lua_touserdata(L, -1);
    lua_pop(L, 1);  /* remove 'Aux' struct */
    runC(b->L, L, b->paniccode);  /* run optional panic code */
    longjmp(b->jb, 1);
    return 1;  /* to avoid warnings */
}

static int checkpanic (lua_State *L) {
    struct Aux b;
    void *ud;
    lua_State *L1;
    const char *code = luaL_checkstring(L, 1);
    lua_Alloc f = lua_getallocf(L, &ud);
    b.paniccode = luaL_optstring(L, 2, "");
    b.L = L;
    L1 = lua_newstate(f, ud);  /* create new state */
    if (L1 == NULL) {  /* error? */
        lua_pushnil(L);
        return 1;
    }
    lua_atpanic(L1, panicback);  /* set its panic function */
    lua_pushlightuserdata(L1, &b);
    lua_setfield(L1, LUA_REGISTRYINDEX, "_jmpbuf");  /* store 'Aux' struct */
    if (setjmp(b.jb) == 0) {  /* set jump buffer */
        runC(L, L1, code);  /* run code unprotected */
        lua_pushliteral(L, "no errors");
    }
    else {  /* error handling */
        /* move error message to original state */
        lua_pushstring(L, lua_tostring(L1, -1));
    }
    lua_close(L1);
    return 1;
}



/*
** {====================================================================
** function to test the API with C. It interprets a kind of assembler
** language with calls to the API, so the test can be driven by Lua code
** =====================================================================
*/


static void sethookaux (lua_State *L, int mask, int count, const char *code);

static const char *const delimits = " \t\n,;";

static void skip (const char **pc) {
    for (;;) {
        if (**pc != '\0' && strchr(delimits, **pc)) (*pc)++;
        else if (**pc == '#') {  /* comment? */
            while (**pc != '\n' && **pc != '\0') (*pc)++;  /* until end-of-line */
        }
        else break;
    }
}

static int getnum_aux (lua_State *L, lua_State *L1, const char **pc) {
    int res = 0;
    int sig = 1;
    skip(pc);
    if (**pc == '.') {
        res = cast_int(lua_tointeger(L1, -1));
        lua_pop(L1, 1);
        (*pc)++;
        return res;
    }
    else if (**pc == '*') {
        res = lua_gettop(L1);
        (*pc)++;
        return res;
    }
    else if (**pc == '-') {
        sig = -1;
        (*pc)++;
    }
    if (!lisdigit(cast_uchar(**pc)))
        luaL_error(L, "number expected (%s)", *pc);
    while (lisdigit(cast_uchar(**pc))) res = res*10 + (*(*pc)++) - '0';
    return sig*res;
}

static const char *getstring_aux (lua_State *L, char *buff, const char **pc) {
    int i = 0;
    skip(pc);
    if (**pc == '"' || **pc == '\'') {  /* quoted string? */
        int quote = *(*pc)++;
        while (**pc != quote) {
            if (**pc == '\0') luaL_error(L, "unfinished string in C script");
            buff[i++] = *(*pc)++;
        }
        (*pc)++;
    }
    else {
        while (**pc != '\0' && !strchr(delimits, **pc))
            buff[i++] = *(*pc)++;
    }
    buff[i] = '\0';
    return buff;
}


static int getindex_aux (lua_State *L, lua_State *L1, const char **pc) {
    skip(pc);
    switch (*(*pc)++) {
    case 'R':
        return LUA_REGISTRYINDEX;
    case 'G':
        return luaL_error(L, "deprecated index 'G'");
    case 'U':
        return lua_upvalueindex(getnum_aux(L, L1, pc));
    default:
        (*pc)--;
        return getnum_aux(L, L1, pc);
    }
}


static const char *const statcodes[] = {"OK", "YIELD", "ERRRUN",
                                        "ERRSYNTAX", MEMERRMSG, "ERRGCMM", "ERRERR"
                                       };

/*
** Avoid these stat codes from being collected, to avoid possible
** memory error when pushing them.
*/
static void regcodes (lua_State *L) {
    unsigned int i;
    for (i = 0; i < sizeof(statcodes) / sizeof(statcodes[0]); i++) {
        lua_pushboolean(L, 1);
        lua_setfield(L, LUA_REGISTRYINDEX, statcodes[i]);
    }
}


#define EQ(s1) (strcmp(s1, inst) == 0)

#define getnum  (getnum_aux(L, L1, &pc))
#define getstring (getstring_aux(L, buff, &pc))
#define getindex (getindex_aux(L, L1, &pc))


static int testC (lua_State *L);
static int Cfunck (lua_State *L, int status, lua_KContext ctx);

/*
** arithmetic operation encoding for 'arith' instruction
** LUA_OPIDIV  -> \
** LUA_OPSHL   -> <
** LUA_OPSHR   -> >
** LUA_OPUNM   -> _
** LUA_OPBNOT  -> !
*/
static const char ops[] = "+-*%^/\\&|~<>_!";

static int runC (lua_State *L, lua_State *L1, const char *pc) {
    char buff[300];
    int status = 0;
    if (pc == NULL) return luaL_error(L, "attempt to runC null script");
    for (;;) {
        const char *inst = getstring;
        if EQ("") return 0;
        else if EQ("absindex") {
            lua_pushnumber(L1, lua_absindex(L1, getindex));
        }
        else if EQ("append") {
            int t = getindex;
            int i = lua_rawlen(L1, t);
            lua_rawseti(L1, t, i + 1);
        }
        else if EQ("arith") {
            int op;
            skip(&pc);
            op = strchr(ops, *pc++) - ops;
            lua_arith(L1, op);
        }
        else if EQ("call") {
            int narg = getnum;
            int nres = getnum;
            lua_call(L1, narg, nres);
        }
        else if EQ("callk") {
            int narg = getnum;
            int nres = getnum;
            int i = getindex;
            lua_callk(L1, narg, nres, i, Cfunck);
        }
        else if EQ("checkstack") {
            int sz = getnum;
            const char *msg = getstring;
            if (*msg == '\0')
                msg = NULL;  /* to test 'luaL_checkstack' with no message */
            luaL_checkstack(L1, sz, msg);
        }
        else if EQ("rawcheckstack") {
            int sz = getnum;
            lua_pushboolean(L1, lua_checkstack(L1, sz));
        }
        else if EQ("compare") {
            const char *opt = getstring;  /* EQ, LT, or LE */
            int op = (opt[0] == 'E') ? LUA_OPEQ
                     : (opt[1] == 'T') ? LUA_OPLT : LUA_OPLE;
            int a = getindex;
            int b = getindex;
            lua_pushboolean(L1, lua_compare(L1, a, b, op));
        }
        else if EQ("concat") {
            lua_concat(L1, getnum);
        }
        else if EQ("copy") {
            int f = getindex;
            lua_copy(L1, f, getindex);
        }
        else if EQ("func2num") {
            lua_CFunction func = lua_tocfunction(L1, getindex);
            lua_pushnumber(L1, cast_sizet(func));
        }
        else if EQ("getfield") {
            int t = getindex;
            lua_getfield(L1, t, getstring);
        }
        else if EQ("getglobal") {
            lua_getglobal(L1, getstring);
        }
        else if EQ("getmetatable") {
            if (lua_getmetatable(L1, getindex) == 0)
                lua_pushnil(L1);
        }
        else if EQ("gettable") {
            lua_gettable(L1, getindex);
        }
        else if EQ("gettop") {
            lua_pushinteger(L1, lua_gettop(L1));
        }
        else if EQ("gsub") {
            int a = getnum;
            int b = getnum;
            int c = getnum;
            luaL_gsub(L1, lua_tostring(L1, a),
                      lua_tostring(L1, b),
                      lua_tostring(L1, c));
        }
        else if EQ("insert") {
            lua_insert(L1, getnum);
        }
        else if EQ("iscfunction") {
            lua_pushboolean(L1, lua_iscfunction(L1, getindex));
        }
        else if EQ("isfunction") {
            lua_pushboolean(L1, lua_isfunction(L1, getindex));
        }
        else if EQ("isnil") {
            lua_pushboolean(L1, lua_isnil(L1, getindex));
        }
        else if EQ("isnull") {
            lua_pushboolean(L1, lua_isnone(L1, getindex));
        }
        else if EQ("isnumber") {
            lua_pushboolean(L1, lua_isnumber(L1, getindex));
        }
        else if EQ("isstring") {
            lua_pushboolean(L1, lua_isstring(L1, getindex));
        }
        else if EQ("istable") {
            lua_pushboolean(L1, lua_istable(L1, getindex));
        }
        else if EQ("isudataval") {
            lua_pushboolean(L1, lua_islightuserdata(L1, getindex));
        }
        else if EQ("isuserdata") {
            lua_pushboolean(L1, lua_isuserdata(L1, getindex));
        }
        else if EQ("len") {
            lua_len(L1, getindex);
        }
        else if EQ("Llen") {
            lua_pushinteger(L1, luaL_len(L1, getindex));
        }
        else if EQ("loadfile") {
            luaL_loadfile(L1, luaL_checkstring(L1, getnum));
        }
        else if EQ("loadstring") {
            const char *s = luaL_checkstring(L1, getnum);
            luaL_loadstring(L1, s);
        }
        else if EQ("newmetatable") {
            lua_pushboolean(L1, luaL_newmetatable(L1, getstring));
        }
        else if EQ("newtable") {
            lua_newtable(L1);
        }
        else if EQ("newthread") {
            lua_newthread(L1);
        }
        else if EQ("resetthread") {
            lua_pushinteger(L1, lua_resetthread(L1));
        }
        else if EQ("newuserdata") {
            lua_newuserdata(L1, getnum);
        }
        else if EQ("next") {
            lua_next(L1, -2);
        }
        else if EQ("objsize") {
            lua_pushinteger(L1, lua_rawlen(L1, getindex));
        }
        else if EQ("pcall") {
            int narg = getnum;
            int nres = getnum;
            status = lua_pcall(L1, narg, nres, getnum);
        }
        else if EQ("pcallk") {
            int narg = getnum;
            int nres = getnum;
            int i = getindex;
            status = lua_pcallk(L1, narg, nres, 0, i, Cfunck);
        }
        else if EQ("pop") {
            lua_pop(L1, getnum);
        }
        else if EQ("printstack") {
            int n = getnum;
            if (n != 0) {
                printf("%s\n", luaL_tolstring(L1, n, NULL));
                lua_pop(L1, 1);
            }
            else printstack(L1);
        }
        else if EQ("print") {
            const char *msg = getstring;
            printf("%s\n", msg);
        }
        else if EQ("warningC") {
            const char *msg = getstring;
            lua_warning(L1, msg, 1);
        }
        else if EQ("warning") {
            const char *msg = getstring;
            lua_warning(L1, msg, 0);
        }
        else if EQ("pushbool") {
            lua_pushboolean(L1, getnum);
        }
        else if EQ("pushcclosure") {
            lua_pushcclosure(L1, testC, getnum);
        }
        else if EQ("pushint") {
            lua_pushinteger(L1, getnum);
        }
        else if EQ("pushnil") {
            lua_pushnil(L1);
        }
        else if EQ("pushnum") {
            lua_pushnumber(L1, (lua_Number)getnum);
        }
        else if EQ("pushstatus") {
            lua_pushstring(L1, statcodes[status]);
        }
        else if EQ("pushstring") {
            lua_pushstring(L1, getstring);
        }
        else if EQ("pushupvalueindex") {
            lua_pushinteger(L1, lua_upvalueindex(getnum));
        }
        else if EQ("pushvalue") {
            lua_pushvalue(L1, getindex);
        }
        else if EQ("pushfstringI") {
            lua_pushfstring(L1, lua_tostring(L, -2), (int)lua_tointeger(L, -1));
        }
        else if EQ("pushfstringS") {
            lua_pushfstring(L1, lua_tostring(L, -2), lua_tostring(L, -1));
        }
        else if EQ("pushfstringP") {
            lua_pushfstring(L1, lua_tostring(L, -2), lua_topointer(L, -1));
        }
        else if EQ("rawget") {
            int t = getindex;
            lua_rawget(L1, t);
        }
        else if EQ("rawgeti") {
            int t = getindex;
            lua_rawgeti(L1, t, getnum);
        }
        else if EQ("rawgetp") {
            int t = getindex;
            lua_rawgetp(L1, t, cast_voidp(cast_sizet(getnum)));
        }
        else if EQ("rawset") {
            int t = getindex;
            lua_rawset(L1, t);
        }
        else if EQ("rawseti") {
            int t = getindex;
            lua_rawseti(L1, t, getnum);
        }
        else if EQ("rawsetp") {
            int t = getindex;
            lua_rawsetp(L1, t, cast_voidp(cast_sizet(getnum)));
        }
        else if EQ("remove") {
            lua_remove(L1, getnum);
        }
        else if EQ("replace") {
            lua_replace(L1, getindex);
        }
        else if EQ("resume") {
            int i = getindex;
            int nres;
            status = lua_resume(lua_tothread(L1, i), L, getnum, &nres);
        }
        else if EQ("return") {
            int n = getnum;
            if (L1 != L) {
                int i;
                for (i = 0; i < n; i++) {
                    int idx = -(n - i);
                    switch (lua_type(L1, idx)) {
                    case LUA_TBOOLEAN:
                        lua_pushboolean(L, lua_toboolean(L1, idx));
                        break;
                    default:
                        lua_pushstring(L, lua_tostring(L1, idx));
                        break;
                    }
                }
            }
            return n;
        }
        else if EQ("rotate") {
            int i = getindex;
            lua_rotate(L1, i, getnum);
        }
        else if EQ("setfield") {
            int t = getindex;
            const char *s = getstring;
            lua_setfield(L1, t, s);
        }
        else if EQ("seti") {
            int t = getindex;
            lua_seti(L1, t, getnum);
        }
        else if EQ("setglobal") {
            const char *s = getstring;
            lua_setglobal(L1, s);
        }
        else if EQ("sethook") {
            int mask = getnum;
            int count = getnum;
            const char *s = getstring;
            sethookaux(L1, mask, count, s);
        }
        else if EQ("setmetatable") {
            int idx = getindex;
            lua_setmetatable(L1, idx);
        }
        else if EQ("settable") {
            lua_settable(L1, getindex);
        }
        else if EQ("settop") {
            lua_settop(L1, getnum);
        }
        else if EQ("testudata") {
            int i = getindex;
            lua_pushboolean(L1, luaL_testudata(L1, i, getstring) != NULL);
        }
        else if EQ("error") {
            lua_error(L1);
        }
        else if EQ("abort") {
            abort();
        }
        else if EQ("throw") {
#if defined(__cplusplus)
            static struct X {
                int x;
            } x;
            throw x;
#else
            luaL_error(L1, "C++");
#endif
            break;
        }
        else if EQ("tobool") {
            lua_pushboolean(L1, lua_toboolean(L1, getindex));
        }
        else if EQ("tocfunction") {
            lua_pushcfunction(L1, lua_tocfunction(L1, getindex));
        }
        else if EQ("tointeger") {
            lua_pushinteger(L1, lua_tointeger(L1, getindex));
        }
        else if EQ("tonumber") {
            lua_pushnumber(L1, lua_tonumber(L1, getindex));
        }
        else if EQ("topointer") {
            lua_pushlightuserdata(L1, cast_voidp(lua_topointer(L1, getindex)));
        }
        else if EQ("touserdata") {
            lua_pushlightuserdata(L1, lua_touserdata(L1, getindex));
        }
        else if EQ("tostring") {
            const char *s = lua_tostring(L1, getindex);
            const char *s1 = lua_pushstring(L1, s);
            lua_longassert((s == NULL && s1 == NULL) || strcmp(s, s1) == 0);
        }
        else if EQ("type") {
            lua_pushstring(L1, luaL_typename(L1, getnum));
        }
        else if EQ("xmove") {
            int f = getindex;
            int t = getindex;
            lua_State *fs = (f == 0) ? L1 : lua_tothread(L1, f);
            lua_State *ts = (t == 0) ? L1 : lua_tothread(L1, t);
            int n = getnum;
            if (n == 0) n = lua_gettop(fs);
            lua_xmove(fs, ts, n);
        }
        else if EQ("isyieldable") {
            lua_pushboolean(L1, lua_isyieldable(lua_tothread(L1, getindex)));
        }
        else if EQ("yield") {
            return lua_yield(L1, getnum);
        }
        else if EQ("yieldk") {
            int nres = getnum;
            int i = getindex;
            return lua_yieldk(L1, nres, i, Cfunck);
        }
        else if EQ("toclose") {
            lua_toclose(L1, getnum);
        }
        else luaL_error(L, "unknown instruction %s", buff);
    }
    return 0;
}


static int testC (lua_State *L) {
    lua_State *L1;
    const char *pc;
    if (lua_isuserdata(L, 1)) {
        L1 = getstate(L);
        pc = luaL_checkstring(L, 2);
    }
    else if (lua_isthread(L, 1)) {
        L1 = lua_tothread(L, 1);
        pc = luaL_checkstring(L, 2);
    }
    else {
        L1 = L;
        pc = luaL_checkstring(L, 1);
    }
    return runC(L, L1, pc);
}


static int Cfunc (lua_State *L) {
    return runC(L, L, lua_tostring(L, lua_upvalueindex(1)));
}


static int Cfunck (lua_State *L, int status, lua_KContext ctx) {
    lua_pushstring(L, statcodes[status]);
    lua_setglobal(L, "status");
    lua_pushinteger(L, ctx);
    lua_setglobal(L, "ctx");
    return runC(L, L, lua_tostring(L, ctx));
}


static int makeCfunc (lua_State *L) {
    luaL_checkstring(L, 1);
    lua_pushcclosure(L, Cfunc, lua_gettop(L));
    return 1;
}


/* }====================================================== */


/*
** {======================================================
** tests for C hooks
** =======================================================
*/

/*
** C hook that runs the C script stored in registry.C_HOOK[L]
*/
static void Chook (lua_State *L, lua_Debug *ar) {
    const char *scpt;
    const char *const events [] = {"call", "ret", "line", "count", "tailcall"};
    lua_getfield(L, LUA_REGISTRYINDEX, "C_HOOK");
    lua_pushlightuserdata(L, L);
    lua_gettable(L, -2);  /* get C_HOOK[L] (script saved by sethookaux) */
    scpt = lua_tostring(L, -1);  /* not very religious (string will be popped) */
    lua_pop(L, 2);  /* remove C_HOOK and script */
    lua_pushstring(L, events[ar->event]);  /* may be used by script */
    lua_pushinteger(L, ar->currentline);  /* may be used by script */
    runC(L, L, scpt);  /* run script from C_HOOK[L] */
}


/*
** sets 'registry.C_HOOK[L] = scpt' and sets 'Chook' as a hook
*/
static void sethookaux (lua_State *L, int mask, int count, const char *scpt) {
    if (*scpt == '\0') {  /* no script? */
        lua_sethook(L, NULL, 0, 0);  /* turn off hooks */
        return;
    }
    lua_getfield(L, LUA_REGISTRYINDEX, "C_HOOK");  /* get C_HOOK table */
    if (!lua_istable(L, -1)) {  /* no hook table? */
        lua_pop(L, 1);  /* remove previous value */
        lua_newtable(L);  /* create new C_HOOK table */
        lua_pushvalue(L, -1);
        lua_setfield(L, LUA_REGISTRYINDEX, "C_HOOK");  /* register it */
    }
    lua_pushlightuserdata(L, L);
    lua_pushstring(L, scpt);
    lua_settable(L, -3);  /* C_HOOK[L] = script */
    lua_sethook(L, Chook, mask, count);
}


static int sethook (lua_State *L) {
    if (lua_isnoneornil(L, 1))
        lua_sethook(L, NULL, 0, 0);  /* turn off hooks */
    else {
        const char *scpt = luaL_checkstring(L, 1);
        const char *smask = luaL_checkstring(L, 2);
        int count = cast_int(luaL_optinteger(L, 3, 0));
        int mask = 0;
        if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
        if (strchr(smask, 'r')) mask |= LUA_MASKRET;
        if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
        if (count > 0) mask |= LUA_MASKCOUNT;
        sethookaux(L, mask, count, scpt);
    }
    return 0;
}


static int coresume (lua_State *L) {
    int status, nres;
    lua_State *co = lua_tothread(L, 1);
    luaL_argcheck(L, co, 1, "coroutine expected");
    status = lua_resume(co, L, 0, &nres);
    if (status != LUA_OK && status != LUA_YIELD) {
        lua_pushboolean(L, 0);
        lua_insert(L, -2);
        return 2;  /* return false + error message */
    }
    else {
        lua_pushboolean(L, 1);
        return 1;
    }
}

/* }====================================================== */



static const struct luaL_Reg tests_funcs[] = {
    {"checkmemory", lua_checkmemory},
    {"closestate", closestate},
    {"d2s", d2s},
    {"doonnewstack", doonnewstack},
    {"doremote", doremote},
    {"gccolor", gc_color},
    {"gcage", gc_age},
    {"gcstate", gc_state},
    {"pobj", gc_printobj},
    {"getref", getref},
    {"hash", hash_query},
    {"log2", log2_aux},
    {"limits", get_limits},
    {"listcode", listcode},
    {"printcode", printcode},
    {"listk", listk},
    {"listabslineinfo", listabslineinfo},
    {"listlocals", listlocals},
    {"loadlib", loadlib},
    {"checkpanic", checkpanic},
    {"newstate", newstate},
    {"newuserdata", newuserdata},
    {"num2int", num2int},
    {"pushuserdata", pushuserdata},
    {"querystr", string_query},
    {"querytab", table_query},
    {"ref", tref},
    {"resume", coresume},
    {"s2d", s2d},
    {"sethook", sethook},
    {"stacklevel", stacklevel},
    {"testC", testC},
    {"makeCfunc", makeCfunc},
    {"totalmem", mem_query},
    {"alloccount", alloc_count},
    {"allocfailnext", alloc_failnext},
    {"trick", settrick},
    {"udataval", udataval},
    {"unref", unref},
    {"upvalue", upvalue},
    {NULL, NULL}
};


static void checkfinalmem (void) {
    lua_assert(l_memcontrol.numblocks == 0);
    lua_assert(l_memcontrol.total == 0);
}


int luaB_opentests (lua_State *L) {
    void *ud;
    lua_atpanic(L, &tpanic);
    lua_setwarnf(L, &warnf, L);
    lua_pushboolean(L, 0);
    lua_setglobal(L, "_WARN");  /* _WARN = false */
    regcodes(L);
    atexit(checkfinalmem);
    lua_assert(lua_getallocf(L, &ud) == debug_realloc);
    lua_assert(ud == cast_voidp(&l_memcontrol));
    lua_setallocf(L, lua_getallocf(L, NULL), ud);
    luaL_newlib(L, tests_funcs);
    return 1;
}

#endif

